package com.tbynet.jwp.service.support;

import com.tbynet.jwp.service.dto.response.TermResponse;
import com.tbynet.jwp.repository.dto.result.TermResult;

import java.math.BigInteger;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 分类项响应构建器
 * 负责构建各种分类项相关的响应对象，提供统一的响应创建接口
 *
 * 设计原则：
 * - 静态工具类：所有方法都是静态的，无需实例化
 * - 链式构建：支持流畅的响应对象构建
 * - 空值安全：自动处理空值，避免NullPointerException
 * - 一致性：确保所有响应对象格式统一
 *
 * @author 佰亿互联
 * @version 2.0
 * @since 2025-11-04
 */
public class TermResponseBuilder {

    /**
     * 私有构造函数，防止实例化
     * 这是一个工具类，不应该被实例化
     */
    private TermResponseBuilder() {
        throw new UnsupportedOperationException("TermResponseBuilder是工具类，不能实例化");
    }

    // ========== 批量操作结果构建方法 ==========

    /**
     * 构建批量操作结果
     */
    public static TermResponse.BatchOperationResult buildBatchResult(
            List<BigInteger> termIds, String taxonomy, List<BigInteger> successIds,
            List<BigInteger> failedIds, List<String> errorMessages, long duration) {
        TermResponse.BatchOperationResult result = new TermResponse.BatchOperationResult();
        result.setTotalCount(termIds.size());
        result.setSuccessCount(successIds.size());
        result.setFailedCount(failedIds.size());
        result.setSuccessIds(successIds);
        result.setFailedIds(failedIds);
        result.setErrorMessages(errorMessages);
        result.setTaxonomy(taxonomy);
        result.setProcessingTimeMs(duration);
        result.setCompletedAt(new Date());

        // 计算成功率
        double successRate = !termIds.isEmpty() ?  (double) successIds.size() / termIds.size() * 100 : 0;
        result.setSuccessRate(successRate);

        return result;
    }

    /**
     * 构建批量操作结果
     * 用于批量删除、批量更新等操作的统一响应格式
     *
     * @param totalCount 总记录数
     * @param successCount 成功数量
     * @param successIds 成功的ID列表
     * @param failedIds 失败的ID列表
     * @return 批量操作结果对象
     */
    public static TermResponse.BatchOperationResult buildBatchResult(
            int totalCount, int successCount, List<BigInteger> successIds, List<BigInteger> failedIds) {
        TermResponse.BatchOperationResult result = new TermResponse.BatchOperationResult();
        // 设置基础统计信息
        result.setTotalCount(totalCount);
        result.setSuccessCount(successCount);
        // 使用空列表避免null值
        result.setSuccessIds(successIds != null ? successIds : new ArrayList<>());
        result.setFailedIds(failedIds != null ? failedIds : new ArrayList<>());
        return result;
    }

    // ========== 列表结果构建方法 ==========

    /**
     * 构建列表响应结果
     * 用于分页查询结果的统一格式
     *
     * @param terms 分类项列表
     * @param totalCount 总记录数
     * @param totalPage 总页数
     * @param pageNumber 当前页码
     * @param pageSize 每页大小
     * @return 列表响应对象
     */
    public static TermResponse.ListResult buildListResult(
            List<TermResponse.BasicInfo> terms, int totalCount, int totalPage, int pageNumber, int pageSize) {
        TermResponse.ListResult result = new TermResponse.ListResult();
        // 设置列表和分页信息
        result.setTerms(terms != null ? terms : new ArrayList<>());
        result.setTotalCount(totalCount);
        result.setTotalPage(totalPage);
        result.setPageNumber(pageNumber);
        result.setPageSize(pageSize);
        return result;
    }

    /**
     * 构建简单列表响应
     * 用于不需要分页的简单列表场景
     *
     * @param terms 分类项列表
     * @return 列表响应对象
     */
    public static TermResponse.ListResult buildSimpleListResult(List<TermResponse.BasicInfo> terms) {
        return buildSimpleListResult(terms, terms != null ? terms.size() : 0);
    }

    /**
     * 构建简单列表响应
     * 指定每页大小的简单列表
     *
     * @param terms 分类项列表
     * @param limit 每页大小
     * @return 列表响应对象
     */
    public static TermResponse.ListResult buildSimpleListResult(List<TermResponse.BasicInfo> terms, int limit) {
        TermResponse.ListResult result = new TermResponse.ListResult();
        // 设置列表和基础分页信息
        result.setTerms(terms != null ? terms : new ArrayList<>());
        result.setTotalCount(terms != null ? terms.size() : 0);
        result.setPageSize(limit);
        result.setPageNumber(1);
        result.setTotalPage(1);
        return result;
    }

    // ========== 合并操作结果构建方法 ==========

    /**
     * 构建合并操作结果
     * 用于分类项合并操作的详细响应
     *
     * @param success 是否成功
     * @param sourceTermId 源分类项ID
     * @param targetTermId 目标分类项ID
     * @param sourceTermName 源分类项名称
     * @param targetTermName 目标分类项名称
     * @param mergedPostCount 转移的文章数量
     * @return 合并操作结果对象
     */
    public static TermResponse.MergeResult buildMergeResult(
            boolean success, BigInteger sourceTermId, BigInteger targetTermId,
            String sourceTermName, String targetTermName, int mergedPostCount) {
        TermResponse.MergeResult result = new TermResponse.MergeResult();
        // 设置合并基本信息
        result.setSuccess(success);
        result.setSourceTermId(sourceTermId);
        result.setTargetTermId(targetTermId);
        result.setSourceTermName(sourceTermName);
        result.setTargetTermName(targetTermName);
        result.setMergedPostCount(mergedPostCount);

        // 根据操作结果设置相应消息
        if (success) {
            result.setMessage(String.format("成功合并分类项: %s -> %s, 合并文章数: %d",
                    sourceTermName, targetTermName, mergedPostCount));
        } else {
            result.setMessage("合并分类项失败");
        }

        return result;
    }

    // ========== 操作结果构建方法 ==========

    /**
     * 构建操作结果
     * 用于通用操作的响应格式
     *
     * @param success 是否成功
     * @param message 操作消息
     * @param termId 分类项ID
     * @return 操作结果对象
     */
    public static TermResponse.OperationResult buildOperationResult(
            boolean success, String message, BigInteger termId) {
        TermResponse.OperationResult result = new TermResponse.OperationResult();
        // 设置操作基本信息
        result.setSuccess(success);
        result.setMessage(message);
        result.setTermId(termId);
        return result;
    }

    // ========== 空结果创建方法 ==========

    /**
     * 构建空的批量操作结果
     * 用于初始化或默认值场景
     *
     * @return 空的批量操作结果对象
     */
    public static TermResponse.BatchOperationResult buildEmptyBatchResult() {
        return buildBatchResult(0, 0, new ArrayList<>(), new ArrayList<>());
    }

    /**
     * 构建空的列表响应结果
     * 用于空列表的统一响应格式
     *
     * @return 空的列表响应对象
     */
    public static TermResponse.ListResult buildEmptyListResult() {
        return buildListResult(new ArrayList<>(), 0, 0, 1, 20);
    }

    /**
     * 创建空的使用分析结果
     * 用于空使用分析结果的统一响应格式
     *
     * @param taxonomy 分类法类型
     * @return 空的使用分析结果对象
     */
    public static TermResponse.UsageAnalysisResult createEmptyUsageAnalysisResult(String taxonomy) {
        TermResponse.UsageAnalysisResult result = new TermResponse.UsageAnalysisResult();
        // 设置基础信息和空数据
        result.setTaxonomy(taxonomy);
        result.setAnalysisPeriod(30);
        result.setTotalUsage(0L);
        result.setDailyUsage(new HashMap<>());
        result.setInsights(new HashMap<>());
        result.setTrendingTerms(new ArrayList<>());
        result.setDecliningTerms(new ArrayList<>());
        return result;
    }

    // ========== 转换操作结果构建方法 ==========

    /**
     * 创建成功的转换结果
     * 用于分类项转换成功场景
     *
     * @param sourceTermId 原始分类项ID
     * @param newTermId 新分类项ID
     * @param sourceTaxonomy 源分类法
     * @param targetTaxonomy 目标分类法
     * @param sourceTerm 源分类项
     * @return 成功的转换结果对象
     */
    public static TermResponse.TransformResult createSuccessTransformResult(
            BigInteger sourceTermId, BigInteger newTermId, String sourceTaxonomy,
            String targetTaxonomy, TermResult sourceTerm) {
        TermResponse.TransformResult result = new TermResponse.TransformResult();
        // 设置转换成功的基本信息
        result.setSuccess(true);
        result.setSourceTermId(sourceTermId);
        result.setNewTermId(newTermId);
        result.setSourceTaxonomy(sourceTaxonomy);
        result.setTargetTaxonomy(targetTaxonomy);

        // 设置分类项名称信息
        if (sourceTerm != null) {
            result.setSourceTermName(sourceTerm.getName());
            result.setNewTermName(sourceTerm.getName());
        }

        result.setMessage(String.format("成功转换分类项: %s -> %s", sourceTaxonomy, targetTaxonomy));
        return result;
    }

    // ========== 别名操作结果构建方法 ==========

    /**
     * 创建成功的别名更新结果
     * 用于别名更新成功场景
     *
     * @param termId 分类项ID
     * @param oldSlug 旧别名
     * @param newSlug 新别名
     * @param termName 分类项名称
     * @return 成功的别名更新结果对象
     */
    public static TermResponse.SlugUpdateResult createSuccessSlugUpdateResult(
            BigInteger termId, String oldSlug, String newSlug, String termName) {
        TermResponse.SlugUpdateResult result = new TermResponse.SlugUpdateResult();
        // 设置别名更新成功的基本信息
        result.setSuccess(true);
        result.setTermId(termId);
        result.setOldSlug(oldSlug);
        result.setNewSlug(newSlug);
        result.setTermName(termName);
        result.setMessage(String.format("成功更新别名: %s -> %s", oldSlug, newSlug));
        return result;
    }

    // ========== 缓存操作结果构建方法 ==========

    /**
     * 创建成功的缓存清理结果
     *
     * @param cleanedCount 清理数量
     * @param termIds 清理的分类项ID列表
     * @param taxonomy 分类法类型
     * @return 缓存清理结果
     */
    public static TermResponse.CacheCleanResult createSuccessResult(
            int cleanedCount, List<BigInteger> termIds, String taxonomy) {
        TermResponse.CacheCleanResult result = new TermResponse.CacheCleanResult();
        result.setSuccess(true);
        result.setCleanedCount(cleanedCount);
        result.setCleanedTermIds(termIds);
        result.setTaxonomy(taxonomy);
        result.setMessage("缓存清理成功");
        return result;
    }

    /**
     * 创建失败的缓存清理结果
     *
     * @param message 错误消息
     * @param taxonomy 分类法类型
     * @return 缓存清理结果
     */
    public static TermResponse.CacheCleanResult createFailedResult(String message, String taxonomy) {
        TermResponse.CacheCleanResult result = new TermResponse.CacheCleanResult();
        result.setSuccess(false);
        result.setCleanedCount(0);
        result.setCleanedTermIds(Collections.emptyList());
        result.setTaxonomy(taxonomy);
        result.setMessage(message);
        return result;
    }

    /**
     * 创建数据完整性检查结果
     * @param taxonomy 分类法类型
     * @param issues 问题列表
     * @param orphanedTerms 孤立分类项数量
     * @param inconsistentCounts 不一致数量
     * @return TermResponse.IntegrityCheckResult
     */
    public static TermResponse.IntegrityCheckResult buildIntegrityCheckResult(
            String taxonomy, List<String> issues, int orphanedTerms, int inconsistentCounts) {
        TermResponse.IntegrityCheckResult result = new TermResponse.IntegrityCheckResult();
        result.setTaxonomy(taxonomy);
        result.setIsConsistent(issues.isEmpty());
        result.setIssues(issues);
        result.setOrphanedTerms(orphanedTerms);
        result.setInconsistentCounts(inconsistentCounts);
        result.setCheckedAt(new Date());
        result.setRepairSuggestion(issues.isEmpty() ? "数据完整性良好" : "建议修复数据不一致问题");
        return result;
    }

    /**
     * 创建关系检查结果
     * @param termId1 分类项ID
     * @param termId2 分类项ID
     * @param taxonomy 分类法类型
     * @param isAncestor 是否是祖先
     * @param isDescendant 是否是后代
     * @param isSibling 是否是兄弟
     * @param relationshipDepth 关系深度
     * @return TermResponse.RelationCheckResult
     */
    public static TermResponse.RelationCheckResult buildRelationCheckResult(
            BigInteger termId1, BigInteger termId2, String taxonomy, boolean isAncestor,
            boolean isDescendant, boolean isSibling, int relationshipDepth) {
        TermResponse.RelationCheckResult result = new TermResponse.RelationCheckResult();
        result.setTermId1(termId1);
        result.setTermId2(termId2);
        result.setIsAncestor(isAncestor);
        result.setIsDescendant(isDescendant);
        result.setIsSibling(isSibling);
        result.setRelationshipDepth(relationshipDepth);
        result.setTaxonomy(taxonomy);
        return result;
    }

    /**
     * 创建推荐结果
     * @param postId 文章ID
     * @param taxonomy 分类法类型
     * @param recommendedTerms 推荐的分类项列表
     * @param confidenceScores 置信度分数
     * @return TermResponse.RecommendationResult
     */
    public static TermResponse.RecommendationResult buildRecommendationResult(
            BigInteger postId, String taxonomy, List<TermResponse.BasicInfo> recommendedTerms,
            Map<String, Double> confidenceScores) {
        TermResponse.RecommendationResult result = new TermResponse.RecommendationResult();
        result.setPostId(postId);
        result.setTaxonomy(taxonomy);
        result.setRecommendedTerms(recommendedTerms);
        result.setConfidenceScores(confidenceScores);
        result.setRecommendationReason("基于热门度和使用模式推荐");
        result.setGeneratedAt(new Date());
        return result;
    }

    /**
     * 将TermResult转换为BasicInfo
     *
     * @param termResult 分类项结果
     * @return 基础信息
     */
    public static TermResponse.BasicInfo convertToBasicInfo(TermResult termResult) {
        if (termResult == null) {
            return null;
        }

        TermResponse.BasicInfo basicInfo = new TermResponse.BasicInfo();
        basicInfo.setTermId(termResult.getTermId());
        basicInfo.setName(termResult.getName());
        basicInfo.setSlug(termResult.getSlug());
        basicInfo.setTaxonomy(termResult.getTaxonomy());
        basicInfo.setDescription(termResult.getDescription());
        basicInfo.setCount(termResult.getCount());
        basicInfo.setParentId(termResult.getParentId());
        return basicInfo;
    }

    /**
     * 将分类法信息转换为响应对象
     *
     * @param taxonomyInfo 分类法信息
     * @return 分类法信息响应
     */
    public static TermResponse.TaxonomyInfo convertToTaxonomyInfo(Map<String, Object> taxonomyInfo) {
        TermResponse.TaxonomyInfo result = new TermResponse.TaxonomyInfo();
        result.setTaxonomy((String) taxonomyInfo.get("taxonomy"));
        result.setLabel((String) taxonomyInfo.get("label"));
        result.setDescription((String) taxonomyInfo.get("description"));
        result.setHierarchical((Boolean) taxonomyInfo.get("hierarchical"));
        result.setPublicFlag((Boolean) taxonomyInfo.get("public"));
        result.setTermCount((Long) taxonomyInfo.get("termCount"));

        @SuppressWarnings("unchecked")
        Map<String, Object> settings = (Map<String, Object>) taxonomyInfo.get("settings");
        result.setSettings(settings);

        // 设置默认分类项
        @SuppressWarnings("unchecked")
        Map<String, Object> defaultTermInfo = (Map<String, Object>) taxonomyInfo.get("defaultTerm");
        if (defaultTermInfo != null) {
            TermResponse.BasicInfo defaultTerm = new TermResponse.BasicInfo();
            defaultTerm.setTermId((BigInteger) defaultTermInfo.get("termId"));
            defaultTerm.setName((String) defaultTermInfo.get("name"));
            defaultTerm.setSlug((String) defaultTermInfo.get("slug"));
            result.setDefaultTerm(defaultTerm);
        }

        return result;
    }

    /**
     * 将使用统计转换为分析结果
     *
     * @param taxonomy 分类法类型
     * @param analysisPeriod 分析周期
     * @param usageStats 使用统计
     * @return 使用分析结果
     */
    public static TermResponse.UsageAnalysisResult convertToUsageAnalysisResult(
            String taxonomy, int analysisPeriod, Map<String, Object> usageStats) {

        TermResponse.UsageAnalysisResult result = new TermResponse.UsageAnalysisResult();
        result.setTaxonomy(taxonomy);
        result.setAnalysisPeriod(analysisPeriod);
        result.setTotalUsage((Long) usageStats.get("totalTerms"));

        @SuppressWarnings("unchecked")
        Map<String, Long> dailyUsage = (Map<String, Long>) usageStats.get("dailyUsage");
        result.setDailyUsage(dailyUsage != null ? dailyUsage : new HashMap<>());

        @SuppressWarnings("unchecked")
        Map<String, Object> insights = (Map<String, Object>) usageStats.get("insights");
        result.setInsights(insights != null ? insights : new HashMap<>());

        // 趋势分类项
        @SuppressWarnings("unchecked")
        List<TermResult> trendingTerms = (List<TermResult>) usageStats.get("popularTerms");
        if (trendingTerms != null) {
            result.setTrendingTerms(trendingTerms.stream()
                    .map(TermResponseBuilder::convertToBasicInfo)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList()));
        } else {
            result.setTrendingTerms(new ArrayList<>());
        }

        // 下降分类项
        @SuppressWarnings("unchecked")
        List<TermResult> decliningTerms = (List<TermResult>) usageStats.get("decliningTerms");
        if (decliningTerms != null) {
            result.setDecliningTerms(decliningTerms.stream()
                    .map(TermResponseBuilder::convertToBasicInfo)
                    .filter(Objects::nonNull)
                    .collect(Collectors.toList()));
        } else {
            result.setDecliningTerms(new ArrayList<>());
        }

        return result;
    }

}